﻿using System;
using System.Globalization;

namespace Inovout
{
    /// <summary>
    /// 参数检查
    /// </summary>
    public static class ArgumentAssert
    {
        public static void IsNotDefault<T>(T argumentValue, string argumentName) where T : struct
        {
            IsNotNull(argumentValue, argumentName);
            if (argumentValue.Equals(default(T)))
                throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.StringResource.ValueCannotBeDefault, argumentName, argumentValue.GetType().Name, argumentName));
        }


        /// <summary>
        /// 检查字符串参数不为空。
        /// </summary>
        /// <param name="argumentValue">需检查的参数值</param>
        /// <param name="argumentName">参数名.</param>
        public static void IsNotDefault(string argumentValue, string argumentName)
        {
            IsNotNull(argumentValue, argumentName);

            if (argumentValue.Length == 0)
                throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.StringResource.StringCannotBeEmpty, argumentName));
        }
      
        /// <summary>
        /// Checks an argument to ensure it isn't null
        /// </summary>
        /// <param name="argumentValue">The argument value to check.</param>
        /// <param name="argumentName">The name of the argument.</param>
        public static void IsNotNull(object argumentValue, string argumentName)
        {
            if (argumentValue == null)
                throw new ArgumentNullException(argumentName);
        }

        public static void IsEnumType(Type enumType, string argumentName)
        {
            IsNotNull(enumType, argumentName);

            if (!enumType.IsEnum)
                throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.StringResource.TypeIsnotEnumType, argumentName,enumType.Name));
        }

        public static void IsNotDefault(object argumentValue, string argumentName)
        {
            IsNotNull(argumentValue, argumentName);
         
            if (Comparer.DefaultValueEquals(argumentValue))
            {
                throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.StringResource.ValueCannotBeDefault, argumentName, argumentValue.GetType().Name, argumentName));
            }
        }
        public static void IsClassType(Type classType, string argumentName)
        {
            IsNotNull(classType, argumentName);
            if (!classType.IsClass)
            {
                throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.StringResource.TypeIsnotClassType, argumentName, classType.Name));
            }
        }

        public static void IsAssignableFrom<TType>(Type type, string argumentName)
        {
            IsNotNull(type, argumentName);
            if (!typeof(TType).IsAssignableFrom(type))
            {
                throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.StringResource.TypeIsnotSubclassOf, argumentName, type.Name));
            }
        }

        public static void AreEquals(int expected, int actual, string argumentName)
        {
            if (!expected.Equals(actual))
                throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.StringResource.ExpectedAreNotActual, argumentName));
        }
    }
}

//public class Assert
//{
//    // 摘要:
//    //     We don't actually want any instances of this object, but some people like
//    //     to inherit from it to add other static methods. Hence, the protected constructor
//    //     disallows any instances of this object.
//    protected Assert();

//    // 摘要:
//    //     Gets the number of assertions executed so far and resets the counter to zero.
//    public static int Counter { get; }

//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    public static void AreEqual(decimal expected, decimal actual);
//    //
//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    public static void AreEqual(int expected, int actual);
//    //
//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    public static void AreEqual(long expected, long actual);
//    //
//    // 摘要:
//    //     Verifies that two objects are equal. Two objects are considered equal if
//    //     both are null, or if both have the same value. NUnit has special semantics
//    //     for some object types.  If they are not equal an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The value that is expected
//    //
//    //   actual:
//    //     The actual value
//    public static void AreEqual(object expected, object actual);
//    //
//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    [CLSCompliant(false)]
//    public static void AreEqual(uint expected, uint actual);
//    //
//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    [CLSCompliant(false)]
//    public static void AreEqual(ulong expected, ulong actual);
//    //
//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void AreEqual(decimal expected, decimal actual, string message);
//    //
//    // 摘要:
//    //     Verifies that two doubles are equal considering a delta. If the expected
//    //     value is infinity then the delta value is ignored. If they are not equal
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   delta:
//    //     The maximum acceptable difference between the the expected and the actual
//    public static void AreEqual(double expected, double actual, double delta);
//    //
//    // 摘要:
//    //     Verifies that two doubles are equal considering a delta. If the expected
//    //     value is infinity then the delta value is ignored. If they are not equal
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   delta:
//    //     The maximum acceptable difference between the the expected and the actual
//    public static void AreEqual(double expected, double? actual, double delta);
//    //
//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void AreEqual(int expected, int actual, string message);
//    //
//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void AreEqual(long expected, long actual, string message);
//    //
//    // 摘要:
//    //     Verifies that two objects are equal. Two objects are considered equal if
//    //     both are null, or if both have the same value. NUnit has special semantics
//    //     for some object types.  If they are not equal an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The value that is expected
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void AreEqual(object expected, object actual, string message);
//    //
//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    [CLSCompliant(false)]
//    public static void AreEqual(uint expected, uint actual, string message);
//    //
//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    [CLSCompliant(false)]
//    public static void AreEqual(ulong expected, ulong actual, string message);
//    //
//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void AreEqual(decimal expected, decimal actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two doubles are equal considering a delta. If the expected
//    //     value is infinity then the delta value is ignored. If they are not equal
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   delta:
//    //     The maximum acceptable difference between the the expected and the actual
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void AreEqual(double expected, double actual, double delta, string message);
//    //
//    // 摘要:
//    //     Verifies that two doubles are equal considering a delta. If the expected
//    //     value is infinity then the delta value is ignored. If they are not equal
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   delta:
//    //     The maximum acceptable difference between the the expected and the actual
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void AreEqual(double expected, double? actual, double delta, string message);
//    //
//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void AreEqual(int expected, int actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void AreEqual(long expected, long actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two objects are equal. Two objects are considered equal if
//    //     both are null, or if both have the same value. NUnit has special semantics
//    //     for some object types.  If they are not equal an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The value that is expected
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void AreEqual(object expected, object actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    [CLSCompliant(false)]
//    public static void AreEqual(uint expected, uint actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two values are equal. If they are not, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    [CLSCompliant(false)]
//    public static void AreEqual(ulong expected, ulong actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two doubles are equal considering a delta. If the expected
//    //     value is infinity then the delta value is ignored. If they are not equal
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   delta:
//    //     The maximum acceptable difference between the the expected and the actual
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void AreEqual(double expected, double actual, double delta, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two doubles are equal considering a delta. If the expected
//    //     value is infinity then the delta value is ignored. If they are not equal
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   delta:
//    //     The maximum acceptable difference between the the expected and the actual
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void AreEqual(double expected, double? actual, double delta, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    public static void AreNotEqual(decimal expected, decimal actual);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    public static void AreNotEqual(double expected, double actual);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    public static void AreNotEqual(float expected, float actual);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    public static void AreNotEqual(int expected, int actual);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    public static void AreNotEqual(long expected, long actual);
//    //
//    // 摘要:
//    //     Verifies that two objects are not equal. Two objects are considered equal
//    //     if both are null, or if both have the same value. NUnit has special semantics
//    //     for some object types.  If they are equal an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The value that is expected
//    //
//    //   actual:
//    //     The actual value
//    public static void AreNotEqual(object expected, object actual);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    [CLSCompliant(false)]
//    public static void AreNotEqual(uint expected, uint actual);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    [CLSCompliant(false)]
//    public static void AreNotEqual(ulong expected, ulong actual);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void AreNotEqual(decimal expected, decimal actual, string message);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void AreNotEqual(double expected, double actual, string message);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void AreNotEqual(float expected, float actual, string message);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void AreNotEqual(int expected, int actual, string message);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void AreNotEqual(long expected, long actual, string message);
//    //
//    // 摘要:
//    //     Verifies that two objects are not equal. Two objects are considered equal
//    //     if both are null, or if both have the same value. NUnit has special semantics
//    //     for some object types.  If they are equal an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The value that is expected
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void AreNotEqual(object expected, object actual, string message);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    [CLSCompliant(false)]
//    public static void AreNotEqual(uint expected, uint actual, string message);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    [CLSCompliant(false)]
//    public static void AreNotEqual(ulong expected, ulong actual, string message);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void AreNotEqual(decimal expected, decimal actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void AreNotEqual(double expected, double actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void AreNotEqual(float expected, float actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void AreNotEqual(int expected, int actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void AreNotEqual(long expected, long actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two objects are not equal. Two objects are considered equal
//    //     if both are null, or if both have the same value. NUnit has special semantics
//    //     for some object types.  If they are equal an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The value that is expected
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void AreNotEqual(object expected, object actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    [CLSCompliant(false)]
//    public static void AreNotEqual(uint expected, uint actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that two values are not equal. If they are equal, then an NUnit.Framework.AssertionException
//    //     is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    [CLSCompliant(false)]
//    public static void AreNotEqual(ulong expected, ulong actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that two objects do not refer to the same object. If they are the
//    //     same an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected object
//    //
//    //   actual:
//    //     The actual object
//    public static void AreNotSame(object expected, object actual);
//    //
//    // 摘要:
//    //     Asserts that two objects do not refer to the same object. If they are the
//    //     same an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected object
//    //
//    //   actual:
//    //     The actual object
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void AreNotSame(object expected, object actual, string message);
//    //
//    // 摘要:
//    //     Asserts that two objects do not refer to the same object. If they are the
//    //     same an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected object
//    //
//    //   actual:
//    //     The actual object
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void AreNotSame(object expected, object actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that two objects refer to the same object. If they are not the same
//    //     an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected object
//    //
//    //   actual:
//    //     The actual object
//    public static void AreSame(object expected, object actual);
//    //
//    // 摘要:
//    //     Asserts that two objects refer to the same object. If they are not the same
//    //     an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected object
//    //
//    //   actual:
//    //     The actual object
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void AreSame(object expected, object actual, string message);
//    //
//    // 摘要:
//    //     Asserts that two objects refer to the same object. If they are not the same
//    //     an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   expected:
//    //     The expected object
//    //
//    //   actual:
//    //     The actual object
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void AreSame(object expected, object actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Helper for Assert.AreEqual(double expected, double actual, ...) allowing
//    //     code generation to work consistently.
//    //
//    // 参数:
//    //   expected:
//    //     The expected value
//    //
//    //   actual:
//    //     The actual value
//    //
//    //   delta:
//    //     The maximum acceptable difference between the the expected and the actual
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    protected static void AssertDoublesAreEqual(double expected, double actual, double delta, string message, object[] args);
//    //
//    // 摘要:
//    //     Verifies that a delegate throws an exception when called and returns it.
//    //
//    // 参数:
//    //   code:
//    //     A TestDelegate
//    public static Exception Catch(TestDelegate code);
//    //
//    // 摘要:
//    //     Verifies that a delegate throws an exception of a certain Type or one derived
//    //     from it when called and returns it.
//    //
//    // 参数:
//    //   code:
//    //     A TestDelegate
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Exception Type
//    public static T Catch<T>(TestDelegate code) where T : Exception;
//    //
//    // 摘要:
//    //     Verifies that a delegate throws an exception when called and returns it.
//    //
//    // 参数:
//    //   code:
//    //     A TestDelegate
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    public static Exception Catch(TestDelegate code, string message);
//    //
//    // 摘要:
//    //     Verifies that a delegate throws an exception of a certain Type or one derived
//    //     from it when called and returns it.
//    //
//    // 参数:
//    //   code:
//    //     A TestDelegate
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Exception Type
//    public static T Catch<T>(TestDelegate code, string message) where T : Exception;
//    //
//    // 摘要:
//    //     Verifies that a delegate throws an exception of a certain Type or one derived
//    //     from it when called and returns it.
//    //
//    // 参数:
//    //   expectedExceptionType:
//    //     The expected Exception Type
//    //
//    //   code:
//    //     A TestDelegate
//    public static Exception Catch(Type expectedExceptionType, TestDelegate code);
//    //
//    // 摘要:
//    //     Verifies that a delegate throws an exception when called and returns it.
//    //
//    // 参数:
//    //   code:
//    //     A TestDelegate
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    public static Exception Catch(TestDelegate code, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that a delegate throws an exception of a certain Type or one derived
//    //     from it when called and returns it.
//    //
//    // 参数:
//    //   code:
//    //     A TestDelegate
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Exception Type
//    public static T Catch<T>(TestDelegate code, string message, params object[] args) where T : Exception;
//    //
//    // 摘要:
//    //     Verifies that a delegate throws an exception of a certain Type or one derived
//    //     from it when called and returns it.
//    //
//    // 参数:
//    //   expectedExceptionType:
//    //     The expected Exception Type
//    //
//    //   code:
//    //     A TestDelegate
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    public static Exception Catch(Type expectedExceptionType, TestDelegate code, string message);
//    //
//    // 摘要:
//    //     Verifies that a delegate throws an exception of a certain Type or one derived
//    //     from it when called and returns it.
//    //
//    // 参数:
//    //   expectedExceptionType:
//    //     The expected Exception Type
//    //
//    //   code:
//    //     A TestDelegate
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    public static Exception Catch(Type expectedExceptionType, TestDelegate code, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that an object is contained in a list.
//    //
//    // 参数:
//    //   expected:
//    //     The expected object
//    //
//    //   actual:
//    //     The list to be examined
//    public static void Contains(object expected, ICollection actual);
//    //
//    // 摘要:
//    //     Asserts that an object is contained in a list.
//    //
//    // 参数:
//    //   expected:
//    //     The expected object
//    //
//    //   actual:
//    //     The list to be examined
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void Contains(object expected, ICollection actual, string message);
//    //
//    // 摘要:
//    //     Asserts that an object is contained in a list.
//    //
//    // 参数:
//    //   expected:
//    //     The expected object
//    //
//    //   actual:
//    //     The list to be examined
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void Contains(object expected, ICollection actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that a delegate does not throw an exception.
//    //
//    // 参数:
//    //   code:
//    //     A TestSnippet delegate
//    public static void DoesNotThrow(TestDelegate code);
//    //
//    // 摘要:
//    //     Verifies that a delegate does not throw an exception.
//    //
//    // 参数:
//    //   code:
//    //     A TestSnippet delegate
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    public static void DoesNotThrow(TestDelegate code, string message);
//    //
//    // 摘要:
//    //     Verifies that a delegate does not throw an exception
//    //
//    // 参数:
//    //   code:
//    //     A TestSnippet delegate
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    public static void DoesNotThrow(TestDelegate code, string message, params object[] args);
//    //
//    // 摘要:
//    //     The Equals method throws an AssertionException. This is done to make sure
//    //     there is no mistake by calling this function.
//    //
//    // 参数:
//    //   a:
//    //
//    //   b:
//    [EditorBrowsable(EditorBrowsableState.Never)]
//    public static bool Equals(object a, object b);
//    //
//    // 摘要:
//    //     Throws an NUnit.Framework.AssertionException. This is used by the other Assert
//    //     functions.
//    public static void Fail();
//    //
//    // 摘要:
//    //     Throws an NUnit.Framework.AssertionException with the message that is passed
//    //     in. This is used by the other Assert functions.
//    //
//    // 参数:
//    //   message:
//    //     The message to initialize the NUnit.Framework.AssertionException with.
//    public static void Fail(string message);
//    //
//    // 摘要:
//    //     Throws an NUnit.Framework.AssertionException with the message and arguments
//    //     that are passed in. This is used by the other Assert functions.
//    //
//    // 参数:
//    //   message:
//    //     The message to initialize the NUnit.Framework.AssertionException with.
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    public static void Fail(string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that a condition is false. If the condition is true the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    public static void False(bool condition);
//    //
//    // 摘要:
//    //     Asserts that a condition is false. If the condition is true the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void False(bool condition, string message);
//    //
//    // 摘要:
//    //     Asserts that a condition is false. If the condition is true the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void False(bool condition, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    public static void Greater(decimal arg1, decimal arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    public static void Greater(double arg1, double arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    public static void Greater(float arg1, float arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    public static void Greater(IComparable arg1, IComparable arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    public static void Greater(int arg1, int arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    public static void Greater(long arg1, long arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    [CLSCompliant(false)]
//    public static void Greater(uint arg1, uint arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    [CLSCompliant(false)]
//    public static void Greater(ulong arg1, ulong arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void Greater(decimal arg1, decimal arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void Greater(double arg1, double arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void Greater(float arg1, float arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void Greater(IComparable arg1, IComparable arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void Greater(int arg1, int arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void Greater(long arg1, long arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    [CLSCompliant(false)]
//    public static void Greater(uint arg1, uint arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    [CLSCompliant(false)]
//    public static void Greater(ulong arg1, ulong arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void Greater(decimal arg1, decimal arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void Greater(double arg1, double arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void Greater(float arg1, float arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void Greater(IComparable arg1, IComparable arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void Greater(int arg1, int arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void Greater(long arg1, long arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    [CLSCompliant(false)]
//    public static void Greater(uint arg1, uint arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than the second value. If it is
//    //     not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    [CLSCompliant(false)]
//    public static void Greater(ulong arg1, ulong arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    public static void GreaterOrEqual(decimal arg1, decimal arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    public static void GreaterOrEqual(double arg1, double arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    public static void GreaterOrEqual(float arg1, float arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    public static void GreaterOrEqual(IComparable arg1, IComparable arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    public static void GreaterOrEqual(int arg1, int arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    public static void GreaterOrEqual(long arg1, long arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    [CLSCompliant(false)]
//    public static void GreaterOrEqual(uint arg1, uint arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    [CLSCompliant(false)]
//    public static void GreaterOrEqual(ulong arg1, ulong arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void GreaterOrEqual(decimal arg1, decimal arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void GreaterOrEqual(double arg1, double arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void GreaterOrEqual(float arg1, float arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void GreaterOrEqual(IComparable arg1, IComparable arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void GreaterOrEqual(int arg1, int arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void GreaterOrEqual(long arg1, long arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    [CLSCompliant(false)]
//    public static void GreaterOrEqual(uint arg1, uint arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    [CLSCompliant(false)]
//    public static void GreaterOrEqual(ulong arg1, ulong arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void GreaterOrEqual(decimal arg1, decimal arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void GreaterOrEqual(double arg1, double arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void GreaterOrEqual(float arg1, float arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void GreaterOrEqual(IComparable arg1, IComparable arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void GreaterOrEqual(int arg1, int arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void GreaterOrEqual(long arg1, long arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    [CLSCompliant(false)]
//    public static void GreaterOrEqual(uint arg1, uint arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is greater than or equal tothe second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be greater
//    //
//    //   arg2:
//    //     The second value, expected to be less
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    [CLSCompliant(false)]
//    public static void GreaterOrEqual(ulong arg1, ulong arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Throws an NUnit.Framework.IgnoreException. This causes the test to be reported
//    //     as ignored.
//    public static void Ignore();
//    //
//    // 摘要:
//    //     Throws an NUnit.Framework.IgnoreException with the message that is passed
//    //     in. This causes the test to be reported as ignored.
//    //
//    // 参数:
//    //   message:
//    //     The message to initialize the NUnit.Framework.AssertionException with.
//    public static void Ignore(string message);
//    //
//    // 摘要:
//    //     Throws an NUnit.Framework.IgnoreException with the message and arguments
//    //     that are passed in. This causes the test to be reported as ignored.
//    //
//    // 参数:
//    //   message:
//    //     The message to initialize the NUnit.Framework.AssertionException with.
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    public static void Ignore(string message, params object[] args);
//    //
//    // 摘要:
//    //     Throws an NUnit.Framework.InconclusiveException. This causes the test to
//    //     be reported as Inconclusive.
//    public static void Inconclusive();
//    //
//    // 摘要:
//    //     Throws an NUnit.Framework.InconclusiveException with the message that is
//    //     passed in. This causes the test to be reported as inconclusive.
//    //
//    // 参数:
//    //   message:
//    //     The message to initialize the NUnit.Framework.InconclusiveException with.
//    public static void Inconclusive(string message);
//    //
//    // 摘要:
//    //     Throws an NUnit.Framework.InconclusiveException with the message and arguments
//    //     that are passed in. This causes the test to be reported as inconclusive.
//    //
//    // 参数:
//    //   message:
//    //     The message to initialize the NUnit.Framework.InconclusiveException with.
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    public static void Inconclusive(string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that an object may be assigned a value of a given Type.
//    //
//    // 参数:
//    //   actual:
//    //     The object under examination
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Type.
//    public static void IsAssignableFrom<T>(object actual);
//    //
//    // 摘要:
//    //     Asserts that an object may be assigned a value of a given Type.
//    //
//    // 参数:
//    //   actual:
//    //     The object under examination
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Type.
//    public static void IsAssignableFrom<T>(object actual, string message);
//    //
//    // 摘要:
//    //     Asserts that an object may be assigned a value of a given Type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type.
//    //
//    //   actual:
//    //     The object under examination
//    public static void IsAssignableFrom(Type expected, object actual);
//    //
//    // 摘要:
//    //     Asserts that an object may be assigned a value of a given Type.
//    //
//    // 参数:
//    //   actual:
//    //     The object under examination
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Type.
//    public static void IsAssignableFrom<T>(object actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that an object may be assigned a value of a given Type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type.
//    //
//    //   actual:
//    //     The object under examination
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsAssignableFrom(Type expected, object actual, string message);
//    //
//    // 摘要:
//    //     Asserts that an object may be assigned a value of a given Type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type.
//    //
//    //   actual:
//    //     The object under examination
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsAssignableFrom(Type expected, object actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Assert that an array, list or other collection is empty
//    //
//    // 参数:
//    //   collection:
//    //     An array, list or other collection implementing ICollection
//    public static void IsEmpty(ICollection collection);
//    //
//    // 摘要:
//    //     Assert that a string is empty - that is equal to string.Empty
//    //
//    // 参数:
//    //   aString:
//    //     The string to be tested
//    public static void IsEmpty(string aString);
//    //
//    // 摘要:
//    //     Assert that an array, list or other collection is empty
//    //
//    // 参数:
//    //   collection:
//    //     An array, list or other collection implementing ICollection
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsEmpty(ICollection collection, string message);
//    //
//    // 摘要:
//    //     Assert that a string is empty - that is equal to string.Empty
//    //
//    // 参数:
//    //   aString:
//    //     The string to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsEmpty(string aString, string message);
//    //
//    // 摘要:
//    //     Assert that an array, list or other collection is empty
//    //
//    // 参数:
//    //   collection:
//    //     An array, list or other collection implementing ICollection
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsEmpty(ICollection collection, string message, params object[] args);
//    //
//    // 摘要:
//    //     Assert that a string is empty - that is equal to string.Empty
//    //
//    // 参数:
//    //   aString:
//    //     The string to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsEmpty(string aString, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that a condition is false. If the condition is true the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    public static void IsFalse(bool condition);
//    //
//    // 摘要:
//    //     Asserts that a condition is false. If the condition is true the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsFalse(bool condition, string message);
//    //
//    // 摘要:
//    //     Asserts that a condition is false. If the condition is true the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsFalse(bool condition, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that an object is an instance of a given type.
//    //
//    // 参数:
//    //   actual:
//    //     The object being examined
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Type
//    public static void IsInstanceOf<T>(object actual);
//    //
//    // 摘要:
//    //     Asserts that an object is an instance of a given type.
//    //
//    // 参数:
//    //   actual:
//    //     The object being examined
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Type
//    public static void IsInstanceOf<T>(object actual, string message);
//    //
//    // 摘要:
//    //     Asserts that an object is an instance of a given type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type
//    //
//    //   actual:
//    //     The object being examined
//    public static void IsInstanceOf(Type expected, object actual);
//    //
//    // 摘要:
//    //     Asserts that an object is an instance of a given type.
//    //
//    // 参数:
//    //   actual:
//    //     The object being examined
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Type
//    public static void IsInstanceOf<T>(object actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that an object is an instance of a given type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type
//    //
//    //   actual:
//    //     The object being examined
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsInstanceOf(Type expected, object actual, string message);
//    //
//    // 摘要:
//    //     Asserts that an object is an instance of a given type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type
//    //
//    //   actual:
//    //     The object being examined
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsInstanceOf(Type expected, object actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that an object is an instance of a given type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type
//    //
//    //   actual:
//    //     The object being examined
//    [Obsolete]
//    public static void IsInstanceOfType(Type expected, object actual);
//    //
//    // 摘要:
//    //     Asserts that an object is an instance of a given type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type
//    //
//    //   actual:
//    //     The object being examined
//    //
//    //   message:
//    //     The message to display in case of failure
//    [Obsolete]
//    public static void IsInstanceOfType(Type expected, object actual, string message);
//    //
//    // 摘要:
//    //     Asserts that an object is an instance of a given type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type
//    //
//    //   actual:
//    //     The object being examined
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    [Obsolete]
//    public static void IsInstanceOfType(Type expected, object actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the double that is passed in is an NaN value.  If the object
//    //     is not NaN then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   aDouble:
//    //     The value that is to be tested
//    public static void IsNaN(double aDouble);
//    //
//    // 摘要:
//    //     Verifies that the double that is passed in is an NaN value.  If the object
//    //     is not NaN then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   aDouble:
//    //     The value that is to be tested
//    public static void IsNaN(double? aDouble);
//    //
//    // 摘要:
//    //     Verifies that the double that is passed in is an NaN value.  If the object
//    //     is not NaN then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   aDouble:
//    //     The value that is to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsNaN(double aDouble, string message);
//    //
//    // 摘要:
//    //     Verifies that the double that is passed in is an NaN value.  If the object
//    //     is not NaN then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   aDouble:
//    //     The value that is to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsNaN(double? aDouble, string message);
//    //
//    // 摘要:
//    //     Verifies that the double that is passed in is an NaN value.  If the object
//    //     is not NaN then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   aDouble:
//    //     The value that is to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsNaN(double aDouble, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the double that is passed in is an NaN value.  If the object
//    //     is not NaN then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   aDouble:
//    //     The value that is to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsNaN(double? aDouble, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that an object may not be assigned a value of a given Type.
//    //
//    // 参数:
//    //   actual:
//    //     The object under examination
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Type.
//    public static void IsNotAssignableFrom<T>(object actual);
//    //
//    // 摘要:
//    //     Asserts that an object may not be assigned a value of a given Type.
//    //
//    // 参数:
//    //   actual:
//    //     The object under examination
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Type.
//    public static void IsNotAssignableFrom<T>(object actual, string message);
//    //
//    // 摘要:
//    //     Asserts that an object may not be assigned a value of a given Type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type.
//    //
//    //   actual:
//    //     The object under examination
//    public static void IsNotAssignableFrom(Type expected, object actual);
//    //
//    // 摘要:
//    //     Asserts that an object may not be assigned a value of a given Type.
//    //
//    // 参数:
//    //   actual:
//    //     The object under examination
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Type.
//    public static void IsNotAssignableFrom<T>(object actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that an object may not be assigned a value of a given Type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type.
//    //
//    //   actual:
//    //     The object under examination
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsNotAssignableFrom(Type expected, object actual, string message);
//    //
//    // 摘要:
//    //     Asserts that an object may not be assigned a value of a given Type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type.
//    //
//    //   actual:
//    //     The object under examination
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsNotAssignableFrom(Type expected, object actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Assert that an array, list or other collection is not empty
//    //
//    // 参数:
//    //   collection:
//    //     An array, list or other collection implementing ICollection
//    public static void IsNotEmpty(ICollection collection);
//    //
//    // 摘要:
//    //     Assert that a string is not empty - that is not equal to string.Empty
//    //
//    // 参数:
//    //   aString:
//    //     The string to be tested
//    public static void IsNotEmpty(string aString);
//    //
//    // 摘要:
//    //     Assert that an array, list or other collection is not empty
//    //
//    // 参数:
//    //   collection:
//    //     An array, list or other collection implementing ICollection
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsNotEmpty(ICollection collection, string message);
//    //
//    // 摘要:
//    //     Assert that a string is not empty - that is not equal to string.Empty
//    //
//    // 参数:
//    //   aString:
//    //     The string to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsNotEmpty(string aString, string message);
//    //
//    // 摘要:
//    //     Assert that an array, list or other collection is not empty
//    //
//    // 参数:
//    //   collection:
//    //     An array, list or other collection implementing ICollection
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsNotEmpty(ICollection collection, string message, params object[] args);
//    //
//    // 摘要:
//    //     Assert that a string is not empty - that is not equal to string.Empty
//    //
//    // 参数:
//    //   aString:
//    //     The string to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsNotEmpty(string aString, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that an object is not an instance of a given type.
//    //
//    // 参数:
//    //   actual:
//    //     The object being examined
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Type
//    public static void IsNotInstanceOf<T>(object actual);
//    //
//    // 摘要:
//    //     Asserts that an object is not an instance of a given type.
//    //
//    // 参数:
//    //   actual:
//    //     The object being examined
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Type
//    public static void IsNotInstanceOf<T>(object actual, string message);
//    //
//    // 摘要:
//    //     Asserts that an object is not an instance of a given type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type
//    //
//    //   actual:
//    //     The object being examined
//    public static void IsNotInstanceOf(Type expected, object actual);
//    //
//    // 摘要:
//    //     Asserts that an object is not an instance of a given type.
//    //
//    // 参数:
//    //   actual:
//    //     The object being examined
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    //
//    // 类型参数:
//    //   T:
//    //     The expected Type
//    public static void IsNotInstanceOf<T>(object actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that an object is not an instance of a given type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type
//    //
//    //   actual:
//    //     The object being examined
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsNotInstanceOf(Type expected, object actual, string message);
//    //
//    // 摘要:
//    //     Asserts that an object is not an instance of a given type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type
//    //
//    //   actual:
//    //     The object being examined
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsNotInstanceOf(Type expected, object actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that an object is not an instance of a given type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type
//    //
//    //   actual:
//    //     The object being examined
//    [Obsolete]
//    public static void IsNotInstanceOfType(Type expected, object actual);
//    //
//    // 摘要:
//    //     Asserts that an object is not an instance of a given type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type
//    //
//    //   actual:
//    //     The object being examined
//    //
//    //   message:
//    //     The message to display in case of failure
//    [Obsolete]
//    public static void IsNotInstanceOfType(Type expected, object actual, string message);
//    //
//    // 摘要:
//    //     Asserts that an object is not an instance of a given type.
//    //
//    // 参数:
//    //   expected:
//    //     The expected Type
//    //
//    //   actual:
//    //     The object being examined
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    [Obsolete]
//    public static void IsNotInstanceOfType(Type expected, object actual, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the object that is passed in is not equal to null If the object
//    //     is null then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   anObject:
//    //     The object that is to be tested
//    public static void IsNotNull(object anObject);
//    //
//    // 摘要:
//    //     Verifies that the object that is passed in is not equal to null If the object
//    //     is null then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   anObject:
//    //     The object that is to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsNotNull(object anObject, string message);
//    //
//    // 摘要:
//    //     Verifies that the object that is passed in is not equal to null If the object
//    //     is null then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   anObject:
//    //     The object that is to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsNotNull(object anObject, string message, params object[] args);
//    //
//    // 摘要:
//    //     Assert that a string is not null or empty
//    //
//    // 参数:
//    //   aString:
//    //     The string to be tested
//    public static void IsNotNullOrEmpty(string aString);
//    //
//    // 摘要:
//    //     Assert that a string is not null or empty
//    //
//    // 参数:
//    //   aString:
//    //     The string to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsNotNullOrEmpty(string aString, string message);
//    //
//    // 摘要:
//    //     Assert that a string is not null or empty
//    //
//    // 参数:
//    //   aString:
//    //     The string to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsNotNullOrEmpty(string aString, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the object that is passed in is equal to null If the object
//    //     is not null then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   anObject:
//    //     The object that is to be tested
//    public static void IsNull(object anObject);
//    //
//    // 摘要:
//    //     Verifies that the object that is passed in is equal to null If the object
//    //     is not null then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   anObject:
//    //     The object that is to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsNull(object anObject, string message);
//    //
//    // 摘要:
//    //     Verifies that the object that is passed in is equal to null If the object
//    //     is not null then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   anObject:
//    //     The object that is to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsNull(object anObject, string message, params object[] args);
//    //
//    // 摘要:
//    //     Assert that a string is either null or equal to string.Empty
//    //
//    // 参数:
//    //   aString:
//    //     The string to be tested
//    public static void IsNullOrEmpty(string aString);
//    //
//    // 摘要:
//    //     Assert that a string is either null or equal to string.Empty
//    //
//    // 参数:
//    //   aString:
//    //     The string to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsNullOrEmpty(string aString, string message);
//    //
//    // 摘要:
//    //     Assert that a string is either null or equal to string.Empty
//    //
//    // 参数:
//    //   aString:
//    //     The string to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsNullOrEmpty(string aString, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that a condition is true. If the condition is false the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    public static void IsTrue(bool condition);
//    //
//    // 摘要:
//    //     Asserts that a condition is true. If the condition is false the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void IsTrue(bool condition, string message);
//    //
//    // 摘要:
//    //     Asserts that a condition is true. If the condition is false the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void IsTrue(bool condition, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    public static void Less(decimal arg1, decimal arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    public static void Less(double arg1, double arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    public static void Less(float arg1, float arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    public static void Less(IComparable arg1, IComparable arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    public static void Less(int arg1, int arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    public static void Less(long arg1, long arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    [CLSCompliant(false)]
//    public static void Less(uint arg1, uint arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    [CLSCompliant(false)]
//    public static void Less(ulong arg1, ulong arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void Less(decimal arg1, decimal arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void Less(double arg1, double arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void Less(float arg1, float arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void Less(IComparable arg1, IComparable arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void Less(int arg1, int arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void Less(long arg1, long arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    [CLSCompliant(false)]
//    public static void Less(uint arg1, uint arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    [CLSCompliant(false)]
//    public static void Less(ulong arg1, ulong arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void Less(decimal arg1, decimal arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void Less(double arg1, double arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void Less(float arg1, float arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void Less(IComparable arg1, IComparable arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void Less(int arg1, int arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void Less(long arg1, long arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    [CLSCompliant(false)]
//    public static void Less(uint arg1, uint arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than the second value. If it is not,
//    //     then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    [CLSCompliant(false)]
//    public static void Less(ulong arg1, ulong arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    public static void LessOrEqual(decimal arg1, decimal arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    public static void LessOrEqual(double arg1, double arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    public static void LessOrEqual(float arg1, float arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    public static void LessOrEqual(IComparable arg1, IComparable arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    public static void LessOrEqual(int arg1, int arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    public static void LessOrEqual(long arg1, long arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    [CLSCompliant(false)]
//    public static void LessOrEqual(uint arg1, uint arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    [CLSCompliant(false)]
//    public static void LessOrEqual(ulong arg1, ulong arg2);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void LessOrEqual(decimal arg1, decimal arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void LessOrEqual(double arg1, double arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void LessOrEqual(float arg1, float arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void LessOrEqual(IComparable arg1, IComparable arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void LessOrEqual(int arg1, int arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void LessOrEqual(long arg1, long arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    [CLSCompliant(false)]
//    public static void LessOrEqual(uint arg1, uint arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    [CLSCompliant(false)]
//    public static void LessOrEqual(ulong arg1, ulong arg2, string message);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void LessOrEqual(decimal arg1, decimal arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void LessOrEqual(double arg1, double arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void LessOrEqual(float arg1, float arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void LessOrEqual(IComparable arg1, IComparable arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void LessOrEqual(int arg1, int arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void LessOrEqual(long arg1, long arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    [CLSCompliant(false)]
//    public static void LessOrEqual(uint arg1, uint arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the first value is less than or equal to the second value.
//    //     If it is not, then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   arg1:
//    //     The first value, expected to be less
//    //
//    //   arg2:
//    //     The second value, expected to be greater
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    [CLSCompliant(false)]
//    public static void LessOrEqual(ulong arg1, ulong arg2, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the object that is passed in is not equal to null If the object
//    //     is null then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   anObject:
//    //     The object that is to be tested
//    public static void NotNull(object anObject);
//    //
//    // 摘要:
//    //     Verifies that the object that is passed in is not equal to null If the object
//    //     is null then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   anObject:
//    //     The object that is to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void NotNull(object anObject, string message);
//    //
//    // 摘要:
//    //     Verifies that the object that is passed in is not equal to null If the object
//    //     is null then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   anObject:
//    //     The object that is to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void NotNull(object anObject, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that the object that is passed in is equal to null If the object
//    //     is not null then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   anObject:
//    //     The object that is to be tested
//    public static void Null(object anObject);
//    //
//    // 摘要:
//    //     Verifies that the object that is passed in is equal to null If the object
//    //     is not null then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   anObject:
//    //     The object that is to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void Null(object anObject, string message);
//    //
//    // 摘要:
//    //     Verifies that the object that is passed in is equal to null If the object
//    //     is not null then an NUnit.Framework.AssertionException is thrown.
//    //
//    // 参数:
//    //   anObject:
//    //     The object that is to be tested
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void Null(object anObject, string message, params object[] args);
//    //
//    // 摘要:
//    //     Throws a NUnit.Framework.SuccessException with the message and arguments
//    //     that are passed in. This allows a test to be cut short, with a result of
//    //     success returned to NUnit.
//    public static void Pass();
//    //
//    // 摘要:
//    //     Throws a NUnit.Framework.SuccessException with the message and arguments
//    //     that are passed in. This allows a test to be cut short, with a result of
//    //     success returned to NUnit.
//    //
//    // 参数:
//    //   message:
//    //     The message to initialize the NUnit.Framework.AssertionException with.
//    public static void Pass(string message);
//    //
//    // 摘要:
//    //     Throws a NUnit.Framework.SuccessException with the message and arguments
//    //     that are passed in. This allows a test to be cut short, with a result of
//    //     success returned to NUnit.
//    //
//    // 参数:
//    //   message:
//    //     The message to initialize the NUnit.Framework.AssertionException with.
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    public static void Pass(string message, params object[] args);
//    //
//    // 摘要:
//    //     override the default ReferenceEquals to throw an AssertionException. This
//    //     implementation makes sure there is no mistake in calling this function as
//    //     part of Assert.
//    //
//    // 参数:
//    //   a:
//    //
//    //   b:
//    public static void ReferenceEquals(object a, object b);
//    //
//    // 摘要:
//    //     Asserts that a condition is true. If the condition is false the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    public static void That(bool condition);
//    //
//    // 摘要:
//    //     Apply a constraint to an actual value, succeeding if the constraint is satisfied
//    //     and throwing an assertion exception on failure.
//    //
//    // 参数:
//    //   expr:
//    //     A Constraint expression to be applied
//    //
//    //   del:
//    //     An ActualValueDelegate returning the value to be tested
//    public static void That(ActualValueDelegate del, IResolveConstraint expr);
//    //
//    // 摘要:
//    //     Asserts that a condition is true. If the condition is false the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    //
//    //   message:
//    //     The message to display if the condition is false
//    public static void That(bool condition, string message);
//    //
//    // 摘要:
//    //     Apply a constraint to an actual value, succeeding if the constraint is satisfied
//    //     and throwing an assertion exception on failure.
//    //
//    // 参数:
//    //   expression:
//    //     A Constraint to be applied
//    //
//    //   actual:
//    //     The actual value to test
//    public static void That(object actual, IResolveConstraint expression);
//    //
//    // 摘要:
//    //     Apply a constraint to a referenced value, succeeding if the constraint is
//    //     satisfied and throwing an assertion exception on failure.
//    //
//    // 参数:
//    //   expression:
//    //     A Constraint to be applied
//    //
//    //   actual:
//    //     The actual value to test
//    public static void That<T>(ref T actual, IResolveConstraint expression);
//    //
//    // 摘要:
//    //     Asserts that the code represented by a delegate throws an exception that
//    //     satisfies the constraint provided.
//    //
//    // 参数:
//    //   code:
//    //     A TestDelegate to be executed
//    //
//    //   constraint:
//    //     A ThrowsConstraint used in the test
//    public static void That(TestDelegate code, IResolveConstraint constraint);
//    //
//    // 摘要:
//    //     Apply a constraint to an actual value, succeeding if the constraint is satisfied
//    //     and throwing an assertion exception on failure.
//    //
//    // 参数:
//    //   expr:
//    //     A Constraint expression to be applied
//    //
//    //   del:
//    //     An ActualValueDelegate returning the value to be tested
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    public static void That(ActualValueDelegate del, IResolveConstraint expr, string message);
//    //
//    // 摘要:
//    //     Asserts that a condition is true. If the condition is false the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    //
//    //   message:
//    //     The message to display if the condition is false
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    public static void That(bool condition, string message, params object[] args);
//    //
//    // 摘要:
//    //     Apply a constraint to an actual value, succeeding if the constraint is satisfied
//    //     and throwing an assertion exception on failure.
//    //
//    // 参数:
//    //   expression:
//    //     A Constraint to be applied
//    //
//    //   actual:
//    //     The actual value to test
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    public static void That(object actual, IResolveConstraint expression, string message);
//    //
//    // 摘要:
//    //     Apply a constraint to a referenced value, succeeding if the constraint is
//    //     satisfied and throwing an assertion exception on failure.
//    //
//    // 参数:
//    //   expression:
//    //     A Constraint to be applied
//    //
//    //   actual:
//    //     The actual value to test
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    public static void That<T>(ref T actual, IResolveConstraint expression, string message);
//    //
//    // 摘要:
//    //     Apply a constraint to an actual value, succeeding if the constraint is satisfied
//    //     and throwing an assertion exception on failure.
//    //
//    // 参数:
//    //   del:
//    //     An ActualValueDelegate returning the value to be tested
//    //
//    //   expr:
//    //     A Constraint expression to be applied
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    public static void That(ActualValueDelegate del, IResolveConstraint expr, string message, params object[] args);
//    //
//    // 摘要:
//    //     Apply a constraint to an actual value, succeeding if the constraint is satisfied
//    //     and throwing an assertion exception on failure.
//    //
//    // 参数:
//    //   expression:
//    //     A Constraint expression to be applied
//    //
//    //   actual:
//    //     The actual value to test
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    public static void That(object actual, IResolveConstraint expression, string message, params object[] args);
//    //
//    // 摘要:
//    //     Apply a constraint to a referenced value, succeeding if the constraint is
//    //     satisfied and throwing an assertion exception on failure.
//    //
//    // 参数:
//    //   expression:
//    //     A Constraint to be applied
//    //
//    //   actual:
//    //     The actual value to test
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    public static void That<T>(ref T actual, IResolveConstraint expression, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that a delegate throws a particular exception when called.
//    //
//    // 参数:
//    //   code:
//    //     A TestSnippet delegate
//    //
//    // 类型参数:
//    //   T:
//    //     Type of the expected exception
//    public static T Throws<T>(TestDelegate code) where T : Exception;
//    //
//    // 摘要:
//    //     Verifies that a delegate throws a particular exception when called.
//    //
//    // 参数:
//    //   expression:
//    //     A constraint to be satisfied by the exception
//    //
//    //   code:
//    //     A TestSnippet delegate
//    public static Exception Throws(IResolveConstraint expression, TestDelegate code);
//    //
//    // 摘要:
//    //     Verifies that a delegate throws a particular exception when called.
//    //
//    // 参数:
//    //   code:
//    //     A TestSnippet delegate
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    //
//    // 类型参数:
//    //   T:
//    //     Type of the expected exception
//    public static T Throws<T>(TestDelegate code, string message) where T : Exception;
//    //
//    // 摘要:
//    //     Verifies that a delegate throws a particular exception when called.
//    //
//    // 参数:
//    //   expectedExceptionType:
//    //     The exception Type expected
//    //
//    //   code:
//    //     A TestSnippet delegate
//    public static Exception Throws(Type expectedExceptionType, TestDelegate code);
//    //
//    // 摘要:
//    //     Verifies that a delegate throws a particular exception when called.
//    //
//    // 参数:
//    //   expression:
//    //     A constraint to be satisfied by the exception
//    //
//    //   code:
//    //     A TestSnippet delegate
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    public static Exception Throws(IResolveConstraint expression, TestDelegate code, string message);
//    //
//    // 摘要:
//    //     Verifies that a delegate throws a particular exception when called.
//    //
//    // 参数:
//    //   code:
//    //     A TestSnippet delegate
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    //
//    // 类型参数:
//    //   T:
//    //     Type of the expected exception
//    public static T Throws<T>(TestDelegate code, string message, params object[] args) where T : Exception;
//    //
//    // 摘要:
//    //     Verifies that a delegate throws a particular exception when called.
//    //
//    // 参数:
//    //   expectedExceptionType:
//    //     The exception Type expected
//    //
//    //   code:
//    //     A TestSnippet delegate
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    public static Exception Throws(Type expectedExceptionType, TestDelegate code, string message);
//    //
//    // 摘要:
//    //     Verifies that a delegate throws a particular exception when called.
//    //
//    // 参数:
//    //   expression:
//    //     A constraint to be satisfied by the exception
//    //
//    //   code:
//    //     A TestSnippet delegate
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    public static Exception Throws(IResolveConstraint expression, TestDelegate code, string message, params object[] args);
//    //
//    // 摘要:
//    //     Verifies that a delegate throws a particular exception when called.
//    //
//    // 参数:
//    //   expectedExceptionType:
//    //     The exception Type expected
//    //
//    //   code:
//    //     A TestSnippet delegate
//    //
//    //   message:
//    //     The message that will be displayed on failure
//    //
//    //   args:
//    //     Arguments to be used in formatting the message
//    public static Exception Throws(Type expectedExceptionType, TestDelegate code, string message, params object[] args);
//    //
//    // 摘要:
//    //     Asserts that a condition is true. If the condition is false the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    public static void True(bool condition);
//    //
//    // 摘要:
//    //     Asserts that a condition is true. If the condition is false the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    //
//    //   message:
//    //     The message to display in case of failure
//    public static void True(bool condition, string message);
//    //
//    // 摘要:
//    //     Asserts that a condition is true. If the condition is false the method throws
//    //     an NUnit.Framework.AssertionException.
//    //
//    // 参数:
//    //   condition:
//    //     The evaluated condition
//    //
//    //   message:
//    //     The message to display in case of failure
//    //
//    //   args:
//    //     Array of objects to be used in formatting the message
//    public static void True(bool condition, string message, params object[] args);
//}
